home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / nevow / appserver.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-03-23  |  16KB  |  335 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''
  5. A web application server built using twisted.web
  6. '''
  7. import cgi
  8. from urllib import unquote
  9. from zope.interface import implements, classImplements
  10. import twisted.python.components as tpc
  11. from twisted.web import server
  12.  
  13. try:
  14.     from twisted.web import http
  15. except ImportError:
  16.     from twisted.protocols import http
  17.  
  18. from twisted.python import log
  19. from twisted.internet import defer
  20. from nevow import context
  21. from nevow import inevow
  22. from nevow import url
  23. from nevow import flat
  24. from nevow import stan
  25.  
  26. class UninformativeExceptionHandler:
  27.     implements(inevow.ICanHandleException)
  28.     
  29.     def renderHTTP_exception(self, ctx, reason):
  30.         request = inevow.IRequest(ctx)
  31.         log.err(reason)
  32.         request.write('<html><head><title>Internal Server Error</title></head>')
  33.         request.write('<body><h1>Internal Server Error</h1>An error occurred rendering the requested page. To see a more detailed error message, enable tracebacks in the configuration.</body></html>')
  34.         request.finishRequest(False)
  35.  
  36.     
  37.     def renderInlineException(self, context, reason):
  38.         log.err(reason)
  39.         return '<div style="border: 1px dashed red; color: red; clear: both">[[ERROR]]</div>'
  40.  
  41.  
  42.  
  43. class DefaultExceptionHandler:
  44.     implements(inevow.ICanHandleException)
  45.     
  46.     def renderHTTP_exception(self, ctx, reason):
  47.         log.err(reason)
  48.         request = inevow.IRequest(ctx)
  49.         request.setResponseCode(http.INTERNAL_SERVER_ERROR)
  50.         request.write('<html><head><title>Exception</title></head><body>')
  51.         failure = failure
  52.         import nevow
  53.         result = failure.formatFailure(reason)
  54.         request.write(''.join(flat.flatten(result)))
  55.         request.write('</body></html>')
  56.         request.finishRequest(False)
  57.  
  58.     
  59.     def renderInlineException(self, context, reason):
  60.         failure = failure
  61.         import nevow
  62.         formatted = failure.formatFailure(reason)
  63.         desc = str(reason)
  64.         return flat.serialize([
  65.             stan.xml('<div style="border: 1px dashed red; color: red; clear: both" onclick="this.childNodes[1].style.display = this.childNodes[1].style.display == \'none\' ? \'block\': \'none\'">'),
  66.             desc,
  67.             stan.xml('<div style="display: none">'),
  68.             formatted,
  69.             stan.xml('</div></div>')], context)
  70.  
  71.  
  72. errorMarker = object()
  73.  
  74. def processingFailed(reason, request, ctx):
  75.     
  76.     try:
  77.         handler = inevow.ICanHandleException(ctx)
  78.         handler.renderHTTP_exception(ctx, reason)
  79.     except:
  80.         request.setResponseCode(http.INTERNAL_SERVER_ERROR)
  81.         log.msg('Exception rendering error page:', isErr = 1)
  82.         log.err()
  83.         log.err('Original exception:', isErr = 1)
  84.         log.err(reason)
  85.         request.write('<html><head><title>Internal Server Error</title></head>')
  86.         request.write('<body><h1>Internal Server Error</h1>An error occurred rendering the requested page. Additionally, an error occured rendering the error page.</body></html>')
  87.         request.finishRequest(False)
  88.  
  89.     return errorMarker
  90.  
  91.  
  92. def defaultExceptionHandlerFactory(ctx):
  93.     return DefaultExceptionHandler()
  94.  
  95.  
  96. class NevowRequest(tpc.Componentized, server.Request):
  97.     '''
  98.     A Request subclass which does additional
  99.     processing if a form was POSTed. When a form is POSTed,
  100.     we create a cgi.FieldStorage instance using the data posted,
  101.     and set it as the request.fields attribute. This way, we can
  102.     get at information about filenames and mime-types of
  103.     files that were posted.
  104.  
  105.     TODO: cgi.FieldStorage blocks while decoding the MIME.
  106.     Rewrite it to do the work in chunks, yielding from time to
  107.     time.
  108.  
  109.     @ivar fields: C{None} or, if the HTTP method is B{POST}, a
  110.         L{cgi.FieldStorage} instance giving the content of the POST.
  111.     '''
  112.     implements(inevow.IRequest)
  113.     fields = None
  114.     
  115.     def __init__(self, *args, **kw):
  116.         server.Request.__init__(self, *args, **kw)
  117.         tpc.Componentized.__init__(self)
  118.  
  119.     
  120.     def process(self):
  121.         if self.method == 'POST':
  122.             t = self.content.tell()
  123.             self.content.seek(0)
  124.             self.fields = cgi.FieldStorage(self.content, self.received_headers, environ = {
  125.                 'REQUEST_METHOD': 'POST' })
  126.             self.content.seek(t)
  127.         
  128.         self.site = self.channel.site
  129.         self.setHeader('server', server.version)
  130.         self.setHeader('date', server.http.datetimeToString())
  131.         self.setHeader('content-type', 'text/html; charset=UTF-8')
  132.         self.prepath = []
  133.         self.postpath = map(unquote, self.path[1:].split('/'))
  134.         self.sitepath = []
  135.         self.deferred = defer.Deferred()
  136.         requestContext = context.RequestContext(parent = self.site.context, tag = self)
  137.         requestContext.remember((), inevow.ICurrentSegments)
  138.         requestContext.remember(tuple(self.postpath), inevow.IRemainingSegments)
  139.         return self.site.getPageContextForRequestContext(requestContext).addErrback(processingFailed, self, requestContext).addCallback(self.gotPageContext)
  140.  
  141.     
  142.     def gotPageContext(self, pageContext):
  143.         if pageContext is not errorMarker:
  144.             return defer.maybeDeferred(pageContext.tag.renderHTTP, pageContext).addBoth(self._cbSetLogger, pageContext).addErrback(processingFailed, self, pageContext).addCallback(self._cbFinishRender, pageContext)
  145.  
  146.     
  147.     def finish(self):
  148.         self.deferred.callback('')
  149.  
  150.     
  151.     def finishRequest(self, success):
  152.         server.Request.finish(self)
  153.  
  154.     
  155.     def _cbFinishRender(self, html, ctx):
  156.         if isinstance(html, str):
  157.             self.write(html)
  158.             self.finishRequest(True)
  159.         elif html is errorMarker:
  160.             pass
  161.         else:
  162.             res = inevow.IResource(html)
  163.             pageContext = context.PageContext(tag = res, parent = ctx)
  164.             return self.gotPageContext(pageContext)
  165.         return isinstance(html, str)
  166.  
  167.     _logger = None
  168.     
  169.     def _cbSetLogger(self, result, ctx):
  170.         
  171.         try:
  172.             logger = ctx.locate(inevow.ILogger)
  173.         except KeyError:
  174.             pass
  175.  
  176.         
  177.         self._logger = lambda : logger.log(ctx)
  178.         return result
  179.  
  180.     session = None
  181.     
  182.     def getSession(self, sessionInterface = None):
  183.         if self.session is not None:
  184.             self.session.touch()
  185.             if sessionInterface:
  186.                 return sessionInterface(self.session)
  187.             return self.session
  188.         return server.Request.getSession(self, sessionInterface)
  189.  
  190.     
  191.     def URLPath(self):
  192.         return url.URL.fromContext(self)
  193.  
  194.     
  195.     def rememberRootURL(self, url = None):
  196.         '''
  197.         Remember the currently-processed part of the URL for later
  198.         recalling.
  199.         '''
  200.         if url is None:
  201.             return server.Request.rememberRootURL(self)
  202.         self.appRootURL = url
  203.  
  204.  
  205.  
  206. def sessionFactory(ctx):
  207.     '''Given a RequestContext instance with a Request as .tag, return a session
  208.     '''
  209.     return ctx.tag.getSession()
  210.  
  211.  
  212. requestFactory = lambda ctx: ctx.tag
  213.  
  214. class NevowSite(server.Site):
  215.     requestFactory = NevowRequest
  216.     
  217.     def __init__(self, resource, *args, **kwargs):
  218.         resource.addSlash = True
  219.         server.Site.__init__(self, resource, *args, **kwargs)
  220.         self.context = context.SiteContext()
  221.  
  222.     
  223.     def remember(self, obj, inter = None):
  224.         """Remember the given object for the given interfaces (or all interfaces
  225.         obj implements) in the site's context.
  226.  
  227.         The site context is the parent of all other contexts. Anything
  228.         remembered here will be available throughout the site.
  229.         """
  230.         self.context.remember(obj, inter)
  231.  
  232.     
  233.     def getPageContextForRequestContext(self, ctx):
  234.         '''Retrieve a resource from this site for a particular request. The
  235.         resource will be wrapped in a PageContext which keeps track
  236.         of how the resource was located.
  237.         '''
  238.         path = inevow.IRemainingSegments(ctx)
  239.         res = inevow.IResource(self.resource)
  240.         pageContext = context.PageContext(tag = res, parent = ctx)
  241.         return defer.maybeDeferred(res.locateChild, pageContext, path).addCallback(self.handleSegment, ctx.tag, path, pageContext)
  242.  
  243.     
  244.     def handleSegment(self, result, request, path, pageContext):
  245.         if result is errorMarker:
  246.             return errorMarker
  247.         (newres, newpath) = result
  248.         if newres is None:
  249.             FourOhFour = FourOhFour
  250.             import nevow.rend
  251.             return context.PageContext(tag = FourOhFour(), parent = pageContext)
  252.         if isinstance(newres, defer.Deferred):
  253.             return (None, None, result is errorMarker, newres is None, newres.addCallback)((lambda actualRes: self.handleSegment((actualRes, newpath), request, path, pageContext)))
  254.         newres = inevow.IResource(newres)
  255.         for x in xrange(len(path) - len(newpath)):
  256.             if request.postpath:
  257.                 request.prepath.append(request.postpath.pop(0))
  258.                 continue
  259.             isinstance(newres, defer.Deferred) if newres is pageContext.tag else newpath is not path
  260.         
  261.         ctx = context.PageContext(tag = newres, parent = pageContext)
  262.         ctx.remember(tuple(request.prepath), inevow.ICurrentSegments)
  263.         ctx.remember(tuple(request.postpath), inevow.IRemainingSegments)
  264.         res = newres
  265.         path = newpath
  266.         if not path:
  267.             return ctx
  268.         return defer.maybeDeferred(res.locateChild, ctx, path).addErrback(processingFailed, request, ctx).addCallback(self.handleSegment, request, path, ctx)
  269.  
  270.     
  271.     def log(self, request):
  272.         if request._logger is None:
  273.             server.Site.log(self, request)
  274.         else:
  275.             request._logger()
  276.  
  277.  
  278.  
  279. class OldResourceAdapter(object):
  280.     implements(inevow.IResource)
  281.     real_prepath_len = None
  282.     
  283.     def __init__(self, original):
  284.         self.original = original
  285.  
  286.     
  287.     def __repr__(self):
  288.         return '<%s @ 0x%x adapting %r>' % (self.__class__.__name__, id(self), self.original)
  289.  
  290.     
  291.     def locateChild(self, ctx, segments):
  292.         request = inevow.IRequest(ctx)
  293.         if self.original.isLeaf:
  294.             self.real_prepath_len = len(request.prepath)
  295.             return (self, ())
  296.         name = segments[0]
  297.         request.prepath.append(request.postpath.pop(0))
  298.         res = self.original.getChildWithDefault(name, request)
  299.         request.postpath.insert(0, request.prepath.pop())
  300.         if isinstance(res, defer.Deferred):
  301.             return (res.addCallback,)((lambda res: (res, segments[1:])))
  302.         return (res, segments[1:])
  303.  
  304.     
  305.     def _handle_NOT_DONE_YET(self, data, request):
  306.         if data == server.NOT_DONE_YET:
  307.             return request.deferred
  308.         return data
  309.  
  310.     
  311.     def renderHTTP(self, ctx):
  312.         request = inevow.IRequest(ctx)
  313.         if self.real_prepath_len is not None:
  314.             path = request.postpath = request.prepath[self.real_prepath_len:]
  315.             del request.prepath[self.real_prepath_len:]
  316.         
  317.         result = defer.maybeDeferred(self.original.render, request).addCallback(self._handle_NOT_DONE_YET, request)
  318.         return result
  319.  
  320.     
  321.     def willHandle_notFound(self, request):
  322.         if hasattr(self.original, 'willHandle_notFound'):
  323.             return self.original.willHandle_notFound(request)
  324.         return False
  325.  
  326.     
  327.     def renderHTTP_notFound(self, ctx):
  328.         return self.original.renderHTTP_notFound(ctx)
  329.  
  330.  
  331. from nevow import rend
  332. NotFound = rend.NotFound
  333. FourOhFour = rend.FourOhFour
  334. classImplements(server.Session, inevow.ISession)
  335.